home *** CD-ROM | disk | FTP | other *** search
/ The CICA Windows Explosion! / The CICA Windows Explosion! - Disc 2.iso / winsock / twnsck12.zip / SRC\COMMANDS.C < prev    next >
Text File  |  1994-12-03  |  15KB  |  683 lines
  1. /*
  2.  *  TwinSock - "Troy's Windows Sockets"
  3.  *
  4.  *  Copyright (C) 1994  Troy Rollo <troy@cbme.unsw.EDU.AU>
  5.  *
  6.  *  This program is free software; you can redistribute it and/or modify
  7.  *  it under the terms of the GNU General Public License as published by
  8.  *  the Free Software Foundation; either version 2 of the License, or
  9.  *  (at your option) any later version.
  10.  *
  11.  *  This program is distributed in the hope that it will be useful,
  12.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  *  GNU General Public License for more details.
  15.  *
  16.  *  You should have received a copy of the GNU General Public License
  17.  *  along with this program; if not, write to the Free Software
  18.  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19.  */
  20.  
  21. #include <stdio.h>
  22. #include <sys/types.h>
  23. #include <netinet/in.h>
  24. #include <netdb.h>
  25. #include <errno.h>
  26. #include <sys/socket.h>
  27. #include "twinsock.h"
  28. #include "tx.h"
  29. #include "wserror.h"
  30.  
  31. #ifdef NEED_H_ERRNO
  32. extern int h_errno;
  33. #endif
  34. #ifdef NO_H_ERRNO
  35. #define h_errno errno
  36. #endif
  37.  
  38. extern void PacketTransmitData (void *pvData, int iDataLen, int iStream);
  39.  
  40. struct
  41. {
  42.     int    iErrnoHost;
  43.     int    iErrnoDos;
  44. } error_mappings[] =
  45. {
  46.     { 0,        0        },
  47.     { EINTR,    WSAEINTR    },
  48.     { EBADF,    WSAEBADF    },
  49.     { EINVAL,    WSAEINVAL    },
  50.     { EMFILE,    WSAEMFILE    },
  51.     { EWOULDBLOCK,    WSAEWOULDBLOCK    },
  52.     { EINPROGRESS,    WSAEINPROGRESS    },
  53.     { EALREADY,    WSAEALREADY    },
  54.     { ENOTSOCK,    WSAENOTSOCK    },
  55.     { EDESTADDRREQ,    WSAEDESTADDRREQ },
  56.     { EMSGSIZE,    WSAEMSGSIZE    },
  57.     { EPROTOTYPE,    WSAEPROTOTYPE    },
  58.     { ENOPROTOOPT,    WSAENOPROTOOPT    },
  59.     { EPROTONOSUPPORT, WSAEPROTONOSUPPORT },
  60.     { ESOCKTNOSUPPORT, WSAESOCKTNOSUPPORT },
  61.     { EOPNOTSUPP,    WSAEOPNOTSUPP    },
  62.     { EPFNOSUPPORT,    WSAEPFNOSUPPORT },
  63.     { EAFNOSUPPORT, WSAEAFNOSUPPORT },
  64.     { EADDRINUSE,    WSAEADDRINUSE    },
  65.     { EADDRNOTAVAIL,WSAEADDRNOTAVAIL },
  66.     { ENETDOWN,    WSAENETDOWN    },
  67.     { ENETUNREACH,    WSAENETUNREACH    },
  68.     { ENETRESET,    WSAENETRESET    },
  69.     { ECONNABORTED,    WSAECONNABORTED    },
  70.     { ECONNRESET,    WSAECONNRESET    },
  71.     { ENOBUFS,    WSAENOBUFS    },
  72.     { EISCONN,    WSAEISCONN    },
  73.     { ENOTCONN,    WSAENOTCONN    },
  74.     { ESHUTDOWN,    WSAESHUTDOWN    },
  75.     { ETOOMANYREFS,    WSAETOOMANYREFS    },
  76.     { ETIMEDOUT,    WSAETIMEDOUT    },
  77.     { ECONNREFUSED,    WSAECONNREFUSED    },
  78.     { ELOOP,    WSAELOOP,    },
  79.     { ENAMETOOLONG,    WSAENAMETOOLONG    },
  80.     { EHOSTDOWN,    WSAEHOSTDOWN    },
  81.     { EHOSTUNREACH,    WSAEHOSTUNREACH    },
  82.     { -1,        -1        }
  83. }, h_error_mappings[] =
  84. { 
  85.     { 0,        0        },
  86.     { HOST_NOT_FOUND, WSAHOST_NOT_FOUND },
  87.     { TRY_AGAIN,    WSATRY_AGAIN    },
  88.     { NO_RECOVERY,    WSANO_RECOVERY    },
  89.     { NO_DATA,    WSANO_DATA    },
  90.     { -1,        -1        }
  91. };
  92.  
  93. /* some functions to allow us to copy integer data
  94.  * to and from unaligned addresses
  95.  */
  96.  
  97. static unsigned short
  98. ToShort(char *pchData)
  99. {
  100.     short    n;
  101.  
  102.     memcpy(&n, pchData, sizeof(short));
  103.     return n;
  104. }
  105.  
  106. static long
  107. ToLong(char *pchData)
  108. {
  109.     long n;
  110.  
  111.     memcpy(&n, pchData, sizeof(long));
  112.     return n;
  113. }
  114.  
  115. static void
  116. FromShort(char *pchData, unsigned short n)
  117. {
  118.     memcpy(pchData, &n, sizeof(short));
  119. }
  120.  
  121. static void
  122. FromLong(char *pchData, long n)
  123. {
  124.     memcpy(pchData, &n, sizeof(long));
  125. }
  126.  
  127. static long
  128. GetIntVal(struct func_arg *pfa)
  129. {
  130.     switch(pfa->at)
  131.     {
  132.     case AT_Int16:
  133.     case AT_Int16Ptr:
  134.         return ntohs(ToShort(pfa->pvData));
  135.  
  136.     case AT_Int32:
  137.     case AT_Int32Ptr:
  138.         return ntohl(ToLong(pfa->pvData));
  139.     }
  140. }
  141.  
  142. void
  143. SetIntVal(struct func_arg *pfa, long iVal)
  144. {
  145.     switch(pfa->at)
  146.     {
  147.     case AT_Int16:
  148.     case AT_Int16Ptr:
  149.         FromShort(pfa->pvData,htons((short) iVal));
  150.         return;
  151.  
  152.     case AT_Int32:
  153.     case AT_Int32Ptr:
  154.         FromLong(pfa->pvData, htonl((short) iVal));
  155.         return;
  156.     }
  157. };
  158.  
  159. struct sockaddr *
  160. ConvertSA(struct func_arg *pfa, struct sockaddr_in *sin)
  161. {
  162.     memcpy(sin, pfa->pvData, sizeof(*sin));
  163.     sin->sin_family = ntohs(sin->sin_family);
  164.     return (struct sockaddr *) sin;
  165. }
  166.  
  167. int
  168. MapError(int iError)
  169. {
  170.     int    i;
  171.  
  172.     for (i = 0; error_mappings[i].iErrnoHost != -1; i++)
  173.     {
  174.         if (error_mappings[i].iErrnoHost == iError)
  175.             return error_mappings[i].iErrnoDos;
  176.     }
  177.     return WSAEFAULT;
  178. }
  179.  
  180. int
  181. MapHError(int iError)
  182. {
  183.     int    i;
  184.  
  185.     for (i = 0; h_error_mappings[i].iErrnoHost != -1; i++)
  186.     {
  187.         if (h_error_mappings[i].iErrnoHost == iError)
  188.             return h_error_mappings[i].iErrnoDos;
  189.     }
  190.     return WSAEFAULT;
  191. }
  192.  
  193. int
  194. CopyString(void *pvData, char *pchString, int iMax)
  195. {
  196.     char    *pchData;
  197.     int    iLen;
  198.  
  199.     pchData = (char *) pvData;
  200.     iLen = strlen(pchString);
  201.     if (iLen + 1 > iMax - 1)
  202.         return 0;
  203.     strcpy(pchData,    pchString);
  204.     return iLen + 1;
  205. }
  206.  
  207. void
  208. CopyHostEnt(void *pvData, struct hostent *phe)
  209. {
  210.     int    iLocation;
  211.     char    *pchData;
  212.     int    i;
  213.  
  214.     pchData = (char *) pvData;
  215.     FromShort(pchData, htons(phe->h_addrtype));
  216.     FromShort(pchData + sizeof(short), htons(phe->h_length));
  217.     for (i = 0; phe->h_addr_list[i]; i++);
  218.     FromShort(pchData + sizeof(short) * 2, htons(i));
  219.     iLocation = sizeof(short) * 3;
  220.     for (i = 0; phe->h_addr_list[i]; i++)
  221.     {
  222.         memcpy(pchData + iLocation, phe->h_addr_list[i], 4);
  223.         iLocation += 4;
  224.     }
  225.     iLocation += CopyString(pchData + iLocation,
  226.                 phe->h_name,
  227.                 MAX_HOST_ENT - iLocation);
  228.     for (i = 0; phe->h_aliases[i]; i++)
  229.     {
  230.         iLocation += CopyString(pchData + iLocation,
  231.                     phe->h_aliases[i],
  232.                     MAX_HOST_ENT - iLocation);
  233.     }
  234.     pchData[iLocation] = 0;
  235. }
  236.  
  237. void
  238. CopyNetEnt(void *pvData, struct netent *pne)
  239. {
  240.     int    iLocation;
  241.     char    *pchData;
  242.     int    i;
  243.  
  244.     pchData = (char *) pvData;
  245.     FromShort(pchData, htons(pne->n_addrtype));
  246.     FromLong(pchData + sizeof(short), pne->n_net);
  247.     iLocation = sizeof(short) + sizeof(long);
  248.     iLocation += CopyString(pchData + iLocation,
  249.                 pne->n_name,
  250.                 MAX_HOST_ENT - iLocation);
  251.     for (i = 0; pne->n_aliases[i]; i++)
  252.     {
  253.         iLocation += CopyString(pchData + iLocation,
  254.                     pne->n_aliases[i],
  255.                     MAX_HOST_ENT - iLocation);
  256.     }
  257.     pchData[iLocation] = 0;
  258. }
  259.  
  260. void
  261. CopyServEnt(void *pvData, struct servent *pse)
  262. {
  263.     int    iLocation;
  264.     char    *pchData;
  265.     int    i;
  266.  
  267.     pchData = (char *) pvData;
  268.     FromShort(pchData, pse->s_port); /* No htons - already in network order */
  269.     iLocation = sizeof(short);
  270.     iLocation += CopyString(pchData + iLocation,
  271.                 pse->s_proto,
  272.                 MAX_HOST_ENT - iLocation);
  273.     iLocation += CopyString(pchData + iLocation,
  274.                 pse->s_name,
  275.                 MAX_HOST_ENT - iLocation);
  276.     for (i = 0; pse->s_aliases[i]; i++)
  277.     {
  278.         iLocation += CopyString(pchData + iLocation,
  279.                     pse->s_aliases[i],
  280.                     MAX_HOST_ENT - iLocation);
  281.     }
  282.     pchData[iLocation] = 0;
  283. }
  284.  
  285. void
  286. CopyProtoEnt(void *pvData, struct protoent *ppe)
  287. {
  288.     int    iLocation;
  289.     char    *pchData;
  290.     int    i;
  291.  
  292.     pchData = (char *) pvData;
  293.     FromShort(pchData, htons(ppe->p_proto));
  294.     iLocation = sizeof(short);
  295.     iLocation += CopyString(pchData + iLocation,
  296.                 ppe->p_name,
  297.                 MAX_HOST_ENT - iLocation);
  298.     for (i = 0; ppe->p_aliases[i]; i++)
  299.     {
  300.         iLocation += CopyString(pchData + iLocation,
  301.                     ppe->p_aliases[i],
  302.                     MAX_HOST_ENT - iLocation);
  303.     }
  304.     pchData[iLocation] = 0;
  305. }
  306.  
  307. void
  308. SwapSockOptIn(    struct func_arg *pfa,
  309.         int    iOpt)
  310. {
  311.     int    iValue;
  312.     char    *pchData;
  313.  
  314.     pchData = (char *) pfa->pvData;
  315.     if (iOpt == SO_LINGER)
  316.     {
  317.         FromShort(pchData, ntohs(ToShort(pchData)));
  318.         FromShort(pchData + sizeof(short),
  319.                 ntohs(ToShort(pchData + sizeof(short))));
  320.     }
  321.     else
  322.     {
  323.         FromLong(pchData, ntohl(ToLong(pchData)));
  324.     }
  325. }
  326.  
  327. void
  328. SwapSockOptOut(    struct func_arg *pfa,
  329.         int    iOpt)
  330. {
  331.     int    iValue;
  332.     char    *pchData;
  333.  
  334.     pchData = (char *) pfa->pvData;
  335.     if (iOpt == SO_LINGER)
  336.     {
  337.         FromShort(pchData, htons(ToShort(pchData)));
  338.         FromShort(pchData + sizeof(short),
  339.                 htons(ToShort(pchData + sizeof(short))));
  340.     }
  341.     else
  342.     {
  343.         FromLong(pchData, htonl(ToLong(pchData)));
  344.     }
  345. }
  346.  
  347. void
  348. ResponseReceived(struct tx_request *ptxr_)
  349. {
  350.     enum Functions ft;
  351.     short    nArgs;
  352.     short    nLen;
  353.     short    id;
  354.     int    iLen;
  355.     int    iValue;
  356.     int    iSocket;
  357.     int    nOptVal;
  358.     short    nError;
  359.     struct    tx_request *ptxr;
  360.     struct    func_arg *pfaArgs;
  361.     struct    func_arg faResult;
  362.     struct    sockaddr_in sin;
  363.     char    *pchData;
  364.     int    i;
  365.     int    iErrorSent;
  366.     int    iOffset;
  367.     struct    hostent *phe;
  368.     struct    netent *pne;
  369.     struct    servent *pse;
  370.     struct    protoent *ppe;
  371.  
  372.     nLen = ntohs(ptxr_->nLen);
  373.     ptxr = (struct tx_request *) malloc(nLen);
  374.     memcpy(ptxr, ptxr_, nLen);
  375.     ft = (enum Functions) ntohs(ptxr->iType);
  376.     nArgs = ntohs(ptxr->nArgs);
  377.  
  378.     pfaArgs = (struct func_arg *) malloc(sizeof(struct func_arg) * nArgs);
  379.     pchData = ptxr->pchData;
  380.     for (i = 0; i < nArgs; i++)
  381.     {
  382.         pfaArgs[i].at = (enum arg_type) ntohs(ToShort(pchData));
  383.         pchData += sizeof(short);
  384.         pfaArgs[i].iLen = ntohs(ToShort(pchData));
  385.         pchData += sizeof(short);
  386.         pfaArgs[i].pvData = pchData;
  387.         pchData += pfaArgs[i].iLen;
  388.     }
  389.     faResult.at = (enum arg_type) ntohs(ToShort(pchData));
  390.     pchData += sizeof(short);
  391.     faResult.iLen = ntohs(ToShort(pchData));
  392.     pchData += sizeof(short);
  393.     faResult.pvData = pchData;
  394.  
  395.     iErrorSent = 0;
  396.     errno = 0;
  397.     h_errno = 0;
  398.  
  399.     switch(ft)
  400.     {
  401.     case FN_IOCtl:
  402.     case FN_Accept:
  403.     case FN_Select:
  404.     case FN_Data:
  405.         ptxr->nError = htons(WSAEOPNOTSUPP);
  406.         ptxr->nLen = htons(sizeof(short) * 5);
  407.         PacketTransmitData(ptxr, sizeof(short) * 5, -2);
  408.         iErrorSent = 1;
  409.         break;
  410.  
  411.     case FN_Send:
  412.         SetIntVal(&faResult,
  413.             send(GetIntVal(&pfaArgs[0]),
  414.                  pfaArgs[1].pvData,
  415.                  GetIntVal(&pfaArgs[2]),
  416.                  GetIntVal(&pfaArgs[3])));
  417.         break;
  418.  
  419.     case FN_SendTo:
  420.         SetIntVal(&faResult,
  421.             sendto(GetIntVal(&pfaArgs[0]),
  422.                    pfaArgs[1].pvData,
  423.                    GetIntVal(&pfaArgs[2]),
  424.                    GetIntVal(&pfaArgs[3]),
  425.                    ConvertSA(&pfaArgs[4], &sin),
  426.                    GetIntVal(&pfaArgs[5])));
  427.         break;
  428.  
  429.     case FN_Bind:
  430.         SetIntVal(&faResult,
  431.             bind(GetIntVal(&pfaArgs[0]),
  432.                  ConvertSA(&pfaArgs[1], &sin),
  433.                  GetIntVal(&pfaArgs[2])));
  434.         break;
  435.  
  436.     case FN_Connect:
  437.         iSocket = GetIntVal(&pfaArgs[0]);
  438.         iValue = connect(iSocket,
  439.                 ConvertSA(&pfaArgs[1], &sin),
  440.                 GetIntVal(&pfaArgs[2]));
  441.         SetIntVal(&faResult, iValue);
  442.         if (iValue != -1)
  443.             BumpLargestFD(iSocket);
  444.         break;
  445.  
  446.     case FN_Close:
  447.         SetIntVal(&faResult,
  448.             close(GetIntVal(&pfaArgs[0])));
  449.         FlushStream(GetIntVal(&pfaArgs[0]));
  450.         SetClosed(GetIntVal(&pfaArgs[0]));
  451.         break;
  452.  
  453.     case FN_Shutdown:
  454.         SetIntVal(&faResult,
  455.             shutdown(GetIntVal(&pfaArgs[0]),
  456.                  GetIntVal(&pfaArgs[1])));
  457.         if (GetIntVal(&pfaArgs[1]) != 1)
  458.             SetClosed(GetIntVal(&pfaArgs[0]));
  459.         break;
  460.  
  461.     case FN_Listen:
  462.         iSocket = GetIntVal(&pfaArgs[0]);
  463.         iValue = listen(iSocket,
  464.                 GetIntVal(&pfaArgs[1]));
  465.         SetIntVal(&faResult, iValue);
  466.         if (iValue != -1)
  467.         {
  468.             BumpLargestFD(iSocket);
  469.             SetListener(iSocket);
  470.         }
  471.         break;
  472.  
  473.     case FN_Socket:
  474.         iSocket = socket(GetIntVal(&pfaArgs[0]),
  475.                 GetIntVal(&pfaArgs[1]),
  476.                 GetIntVal(&pfaArgs[2]));
  477.         SetIntVal(&faResult,iSocket);
  478.         if (iSocket != -1)
  479.         {
  480.             BumpLargestFD(iSocket);
  481.             nOptVal = 1;
  482.             iLen = sizeof(nOptVal);
  483.             setsockopt(iSocket,
  484.                     SOL_SOCKET,
  485.                     SO_OOBINLINE,
  486.                     (char *) &nOptVal,
  487.                     iLen);
  488.             errno = 0;
  489.         }
  490.         break;
  491.  
  492.     case FN_GetPeerName:
  493.         iLen = GetIntVal(&pfaArgs[2]);
  494.         iValue = getpeername(GetIntVal(&pfaArgs[0]),
  495.                      (struct sockaddr *) pfaArgs[1].pvData,
  496.                      &iLen);
  497.         if (iValue != -1)
  498.         {
  499.             SetIntVal(&faResult, iValue);
  500.             SetIntVal(&pfaArgs[2], iValue);
  501.             iValue = ((struct sockaddr *) pfaArgs[1].pvData)->
  502.                         sa_family;
  503.             iValue = htons((short) iValue);
  504.             ((struct sockaddr *) pfaArgs[1].pvData)->sa_family =
  505.                         (short) iValue;
  506.         }
  507.         break;
  508.  
  509.     case FN_GetSockName:
  510.         iLen = GetIntVal(&pfaArgs[2]);
  511.         iValue = getsockname(GetIntVal(&pfaArgs[0]),
  512.                      (struct sockaddr *) pfaArgs[1].pvData,
  513.                      &iLen);
  514.         if (iValue != -1)
  515.         {
  516.             SetIntVal(&faResult, iValue);
  517.             SetIntVal(&pfaArgs[2], iValue);
  518.             iValue = ((struct sockaddr *) pfaArgs[1].pvData)->
  519.                         sa_family;
  520.             iValue = htons((short) iValue);
  521.             ((struct sockaddr *) pfaArgs[1].pvData)->sa_family =
  522.                         (short) iValue;
  523.         }
  524.         break;
  525.  
  526.     case FN_GetSockOpt:
  527.         iLen = GetIntVal(&pfaArgs[4]);
  528.         iValue = getsockopt(    GetIntVal(&pfaArgs[0]),
  529.                     GetIntVal(&pfaArgs[1]),
  530.                     GetIntVal(&pfaArgs[2]),
  531.                     (char *) pfaArgs[3].pvData,
  532.                     &iLen);
  533.         if (iValue != -1)
  534.         {
  535.             SwapSockOptOut(&pfaArgs[3],
  536.                     GetIntVal(&pfaArgs[2]));
  537.             SetIntVal(&pfaArgs[4], iLen);
  538.         }
  539.         SetIntVal(&faResult, iValue);
  540.         break;
  541.  
  542.     case FN_SetSockOpt:
  543.         iLen = GetIntVal(&pfaArgs[4]);
  544.         SwapSockOptIn(&pfaArgs[3],
  545.                 GetIntVal(&pfaArgs[2]));
  546.         iValue = setsockopt(    GetIntVal(&pfaArgs[0]),
  547.                     SOL_SOCKET,
  548.                     GetIntVal(&pfaArgs[2]),
  549.                     (char *) pfaArgs[3].pvData,
  550.                     iLen);
  551.         SwapSockOptOut(&pfaArgs[3],
  552.                 GetIntVal(&pfaArgs[2]));
  553.         SetIntVal(&faResult, iValue);
  554.         break;
  555.  
  556.     case FN_GetHostName:
  557.         SetIntVal(&faResult,
  558.             gethostname((char *) pfaArgs[0].pvData,
  559.                     GetIntVal(&pfaArgs[1])));
  560.         break;
  561.  
  562.     case FN_HostByAddr:
  563.         phe = gethostbyaddr((char *) pfaArgs[0].pvData,
  564.                     GetIntVal(&pfaArgs[1]),
  565.                     GetIntVal(&pfaArgs[2]));
  566.         if (phe)
  567.         {
  568.             h_errno = 0;
  569.             CopyHostEnt(faResult.pvData, phe);
  570.         }
  571.         break;
  572.  
  573.     case FN_HostByName:
  574.         phe = gethostbyname((char *) pfaArgs[0].pvData);
  575.         if (phe)
  576.         {
  577.             h_errno = 0;
  578.             CopyHostEnt(faResult.pvData, phe);
  579.         }
  580.         else if (!h_errno)
  581.         {
  582.             h_errno = TRY_AGAIN;
  583.         }
  584.         break;
  585.  
  586.     case FN_ServByPort:
  587.         if (pfaArgs[0].at == AT_Int16)
  588.             iValue = *(short *) pfaArgs[0].pvData;
  589.         else
  590.             iValue = *(long *) pfaArgs[0].pvData;
  591.         pse = getservbyport(iValue,
  592.                     (char *) pfaArgs[1].pvData);
  593.         if (pse)
  594.         {
  595.             h_errno = 0;
  596.             CopyServEnt(faResult.pvData, pse);
  597.         }
  598.         else
  599.         {
  600.             h_errno = NO_DATA;
  601.         }
  602.         break;
  603.  
  604.     case FN_ServByName:
  605.         pse = getservbyname((char *) pfaArgs[0].pvData,
  606.                     (char *) pfaArgs[1].pvData);
  607.         if (pse)
  608.         {
  609.             h_errno = 0;
  610.             CopyServEnt(faResult.pvData, pse);
  611.         }
  612.         else
  613.         {
  614.             h_errno = NO_DATA;
  615.         }
  616.         break;
  617.  
  618.     case FN_ProtoByNumber:
  619.         ppe = getprotobynumber(GetIntVal(&pfaArgs[0]));
  620.         if (ppe)
  621.         {
  622.             h_errno = 0;
  623.             CopyProtoEnt(faResult.pvData, ppe);
  624.         }
  625.         else
  626.         {
  627.             h_errno = NO_DATA;
  628.         }
  629.         break;
  630.  
  631.     case FN_ProtoByName:
  632.         ppe = getprotobyname((char *) pfaArgs[0].pvData);
  633.         if (ppe)
  634.         {
  635.             h_errno = 0;
  636.             CopyProtoEnt(faResult.pvData, ppe);
  637.         }
  638.         else
  639.         {
  640.             h_errno = NO_DATA;
  641.         }
  642.         break;
  643.     }
  644.     if (!iErrorSent)
  645.     {
  646.         if (ft >= FN_HostByAddr && ft <= FN_ProtoByName)
  647.             ptxr->nError = htons(MapHError(h_errno));
  648.         else
  649.             ptxr->nError = htons(MapError(errno));
  650.         PacketTransmitData(ptxr, nLen, -2);
  651.     }
  652.     free(ptxr);
  653.     free(pfaArgs);
  654. }
  655.  
  656. void
  657. SendSocketData(int iSocket,
  658.         void    *pvData,
  659.         int    iLen,
  660.         struct sockaddr_in *psa,
  661.         int    iAddrLen,
  662.         enum Functions ft)
  663. {
  664.     struct    tx_request *ptxr;
  665.     int    iDataLen;
  666.     struct    sockaddr_in sa;
  667.  
  668.     iDataLen = sizeof(struct sockaddr_in) + iLen;
  669.     sa = *psa;
  670.     sa.sin_family = htons(sa.sin_family);
  671.     ptxr = (struct tx_request *) malloc(sizeof(short) * 5 + iDataLen);
  672.     ptxr->nLen = htons(iDataLen + sizeof(short) * 5);
  673.     ptxr->id = htons(iSocket);
  674.     ptxr->nArgs = 0;
  675.     ptxr->nError = 0;
  676.     ptxr->iType = htons(ft);
  677.     memcpy(ptxr->pchData, &sa, sizeof(sa));
  678.     memcpy(ptxr->pchData + sizeof(sa), pvData, iLen);
  679.     PacketTransmitData(ptxr, sizeof(short) * 5 + iDataLen,
  680.         (ft == FN_Data) ? iSocket : -2);
  681.     free(ptxr);
  682. }
  683.